home *** CD-ROM | disk | FTP | other *** search
/ Network CD 2 / Network CD - Volume 2.iso / programs / internet / dnet / dnetsolaris.lzh / lib / dnetlib.c next >
Encoding:
C/C++ Source or Header  |  1994-04-17  |  6.1 KB  |  371 lines
  1.  
  2. /*
  3.  *  DNETLIB.C
  4.  *
  5.  *    DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  Library Interface for DNET.
  8.  */
  9.  
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <fcntl.h>
  13. #include <signal.h>
  14. #include <stdio.h>
  15. #include <errno.h>
  16. #ifdef O_CREAT
  17. #include <sys/file.h>
  18. #endif
  19. #include "../lib/dnetlib.h"
  20.  
  21. extern char *getenv();
  22.  
  23. #ifndef sequent 
  24. #ifndef SYSV
  25. typedef unsigned long ulong;
  26. #endif
  27. typedef unsigned char ubyte;
  28. #else
  29. /* I defined ulong, etc, in my own system headers, while fixing soda's -ERic */
  30. #ifndef SYSV
  31. #define ulong u_long
  32. #endif
  33. #define ubyte u_char
  34. #endif
  35. typedef unsigned short uword;
  36.  
  37. typedef struct sockaddr SOCKADDR;
  38.  
  39. typedef struct {
  40.     int s;
  41.     uword port;
  42. } CHANN;
  43.  
  44. #define NAMELEN sizeof(".PORT.XXXXX")
  45. #define NAMEPAT "%s.PORT.%ld"
  46.  
  47. char *getdirpart();
  48.  
  49. CHANN *
  50. DListen(port)
  51. uword port;
  52. {
  53.     CHANN *chan;
  54.     int s;
  55.     SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
  56.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  57.  
  58.     sprintf(sa->sa_data, NAMEPAT, dirstr, port);
  59.     sa->sa_family = AF_UNIX;
  60.     unlink(sa->sa_data);
  61.  
  62.     s = socket(PF_UNIX, SOCK_STREAM, 0);
  63.     fcntl(s, F_SETOWN, getpid());
  64.     if (bind(s, sa, sizeof(*sa)-sizeof(sa->sa_data)+strlen(sa->sa_data)) < 0) {
  65.     close(s);
  66.     free(sa);
  67.     return(NULL);
  68.     }
  69.     if (listen(s, 5) < 0) {
  70.     close(s);
  71.     unlink(sa->sa_data);
  72.     free(sa);
  73.     return(NULL);
  74.     }
  75.     chan = (CHANN *)malloc(sizeof(CHANN));
  76.     chan->s = s;
  77.     chan->port = port;
  78.     free(sa);
  79.     return(chan);
  80. }
  81.  
  82.  
  83. DUnListen(chan)
  84. CHANN *chan;
  85. {
  86.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  87.     char buf[32];
  88.  
  89.     close(chan->s);
  90.     sprintf(buf, NAMEPAT, dirstr, chan->port);
  91.     unlink(buf);
  92.     free(chan);
  93. }
  94.  
  95. DAccept(chan)
  96. CHANN *chan;
  97. {
  98.     SOCKADDR sa;
  99.     int addrlen = sizeof(sa);
  100.     int fd;
  101.  
  102.     fd = accept(chan->s, &sa, &addrlen);
  103.     return(fd);
  104. }
  105.  
  106. DOpen(host, port, txpri, rxpri)
  107. char *host;
  108. uword port;
  109. char txpri, rxpri;
  110. {
  111.     int s;
  112.     char rc;
  113.     short xb[3];
  114.     SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
  115.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  116.  
  117.     if (rxpri < -127)
  118.     rxpri = -127;
  119.     if (rxpri > 126)
  120.     rxpri = 126;
  121.     if (txpri < -127)
  122.     txpri = -127;
  123.     if (txpri > 126)
  124.     txpri = 126;
  125.  
  126.     if (host == NULL)
  127.     host = (getenv("DNETHOST")) ? getenv("DNETHOST"):"3";
  128.  
  129.     sa->sa_family = AF_UNIX;
  130.     sprintf(sa->sa_data, "%s%s%s", dirstr, "DNET.", host);
  131.  
  132.     s = socket(PF_UNIX, SOCK_STREAM, 0);
  133.     fcntl(s, F_SETOWN, getpid());
  134.     if (connect(s, sa, sizeof(sa->sa_family) + strlen(sa->sa_data)) < 0) {
  135.     close(s);
  136.     free(sa);
  137.     return(-1);
  138.     }
  139.     free(sa);
  140.     xb[0] = port;
  141.     ((char *)&xb[1])[0] = txpri;
  142.     ((char *)&xb[1])[1] = rxpri;
  143.     write(s, xb, 4);
  144.     if (read(s, &rc, 1) == 1 && rc == 0)
  145.     return(s);
  146.     close(s);
  147.     return(-1);
  148. }
  149.  
  150. DEof(fd)
  151. {
  152.     char dummy;
  153.  
  154.     shutdown(fd, 1);
  155.     write(fd, &dummy, 0);
  156. }
  157.  
  158. gwrite(fd, buf, bytes)
  159. char *buf;
  160. {
  161.     int n;
  162.     int orig = bytes;
  163.     extern int errno;
  164.     while (bytes) {
  165.     n = write(fd, buf, bytes);
  166.     if (n > 0) {
  167.         bytes -= n;
  168.         buf += n;
  169.         continue;
  170.     }
  171.     if (n < 0) {
  172.         if (errno == EINTR)
  173.         continue;
  174.         if (errno == EWOULDBLOCK) {
  175.         int wm = 1 << fd;
  176.         int em = 1 << fd;
  177.         if (select(fd+1, NULL, &wm, &em, NULL) < 0)
  178.             continue;
  179.         if (wm)
  180.             continue;
  181.         }
  182.         return(orig - bytes);
  183.     }
  184.     }
  185.     return(orig);
  186. }
  187.  
  188. gread(fd, buf, bytes)
  189. char *buf;
  190. {
  191.     int n;
  192.     int orig = bytes;
  193.     extern int errno;
  194.     while (bytes) {
  195.     n = read(fd, buf, bytes);
  196.     if (n > 0) {
  197.         bytes -= n;
  198.         buf += n;
  199.         break;
  200.     }
  201.     if (n < 0) {
  202.         if (errno == EINTR)
  203.         continue;
  204.         if (errno == EWOULDBLOCK) {
  205.         int rm = 1 << fd;
  206.         int em = 1 << fd;
  207.         if (select(fd+1, &rm, NULL, &em, NULL) < 0)
  208.             continue;
  209.         if (rm)
  210.             continue;
  211.         }
  212.         return(orig - bytes);
  213.     }
  214.     if (n == 0)
  215.         break;
  216.     }
  217.     return(orig - bytes);
  218. }
  219.  
  220. ggread(fd, buf, bytes)
  221. char *buf;
  222. {
  223.     int n;
  224.     int ttl = 0;
  225.     while (bytes) {
  226.     n = gread(fd, buf, bytes);
  227.     if (n > 0) {
  228.         bytes -= n;
  229.         buf += n;
  230.         ttl += n;
  231.         continue;
  232.     }
  233.     return(-1);
  234.     }
  235.     return(ttl);
  236. }
  237.  
  238. /*
  239.  *    Convert to and from 68000 longword format.  Of course, it really
  240.  *    doesn't matter what format you use, just as long as it is defined.
  241.  */
  242.  
  243. ntohl68(n)
  244. ulong n;
  245. {
  246.     return(
  247.     (((ubyte *)&n)[0] << 24)|
  248.     (((ubyte *)&n)[1] << 16)|
  249.     (((ubyte *)&n)[2] << 8)|
  250.     (((ubyte *)&n)[3])
  251.     );
  252. }
  253.  
  254. htonl68(n)
  255. ulong n;
  256. {
  257.     ulong v;
  258.     ((ubyte *)&v)[0] = n >> 24;
  259.     ((ubyte *)&v)[1] = n >> 16;
  260.     ((ubyte *)&v)[2] = n >> 8;
  261.     ((ubyte *)&v)[3] = n;
  262.     return(v);
  263. }
  264.  
  265.  
  266. DoOption(ac, av, ops, args)
  267. short ac;
  268. char *av[];
  269. char *ops;
  270. long args;
  271. {
  272.     register short i;
  273.     short j;
  274.  
  275.     for (i = j = 1; i < ac; ++i) {
  276.     register char *ptr = av[i];
  277.     if (*ptr != '-') {
  278.         av[j++] = av[i];
  279.         continue;
  280.     }
  281.     while (*++ptr) {
  282.         register char *op;
  283.         long **ap = (long **)&args;
  284.         short isshort;
  285.  
  286.         for (op = ops; *op && *op != *ptr;) {
  287.         if (*op == *ptr)
  288.             break;
  289.         if (*++op == '%') {
  290.             while (*op && *op != 's' && *op != 'd')
  291.             ++op;
  292.             if (*op)
  293.             ++op;
  294.         }
  295.         if (*op == ',')     /*  optional ,  */
  296.             ++op;
  297.         ++ap;
  298.         }
  299.         if (*op == 0)
  300.         return(-1);
  301.         if (op[1] != '%') {
  302.         *(short *)*ap = 1;
  303.         ++ap;
  304.         continue;
  305.         }
  306.         op += 2;
  307.         isshort = 1;
  308.         while (*op && *op != 's' && *op != 'd') {
  309.         switch(*op) {
  310.         case 'h':
  311.             isshort = 1;
  312.             break;
  313.         case 'l':
  314.             isshort = 0;
  315.             break;
  316.         default:
  317.             return(-1);
  318.         }
  319.         ++op;
  320.         }
  321.         switch(*op) {
  322.         case 's':
  323.         if (ptr[1]) {
  324.             *(char **)*ap = ptr + 1;
  325.             ptr = "\0";
  326.         } else {
  327.             *(char **)*ap = av[++i];
  328.         }
  329.         break;
  330.         case 'd':
  331.         if (isshort)
  332.             *(short *)*ap = atoi(++ptr);
  333.         else
  334.             *(long *)*ap = atoi(++ptr);
  335.         while (*ptr >= '0' && *ptr <= '9')
  336.             ++ptr;
  337.         break;
  338.         default:
  339.         return(-1);
  340.         }
  341.     }
  342.     }
  343.     return(j);
  344. }
  345.  
  346. elog(how, ctl, arg)
  347. char *ctl;
  348. long arg;
  349. {
  350.     char *dir = getenv("DNETDIR");
  351.     FILE *fi;
  352.     char buf[256];
  353.     long dtime;
  354.  
  355.     time(&dtime);
  356.  
  357.     if (!dir)
  358.     dir = "";
  359.     sprintf(buf, "%s%s", dir, "DNET.LOG");
  360.     if (fi = fopen(buf, "a")) {
  361.     strcpy(buf, ctime(&dtime));
  362.     buf[strlen(buf)-1] = 0;
  363.     fprintf(fi, "%s ", buf);
  364.     fprintf(fi, ctl, arg);
  365.     putc('\n', fi);
  366.     fclose(fi);
  367.     }
  368.     if (how == EFATAL)
  369.     exit(1);
  370. }
  371.